{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside `cs231n/classifiers/softmax.py`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.368449\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 1**\n",
    "\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ *Because There are $10$ classes of objects, and there is only one is true, which means the loss should be $-log(1/10)$.* \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: -0.845005 analytic: -0.845005, relative error: 2.309280e-09\n",
      "numerical: 0.136094 analytic: 0.136094, relative error: 1.585279e-07\n",
      "numerical: 0.271689 analytic: 0.271689, relative error: 1.414758e-07\n",
      "numerical: -3.431588 analytic: -3.431588, relative error: 1.028935e-08\n",
      "numerical: -0.977576 analytic: -0.977576, relative error: 5.249715e-11\n",
      "numerical: -0.923505 analytic: -0.923505, relative error: 1.149436e-08\n",
      "numerical: 0.262651 analytic: 0.262651, relative error: 1.495188e-07\n",
      "numerical: 1.390560 analytic: 1.390560, relative error: 1.008137e-08\n",
      "numerical: 0.507190 analytic: 0.507190, relative error: 3.101446e-08\n",
      "numerical: -2.434014 analytic: -2.434014, relative error: 1.321271e-08\n",
      "numerical: 1.191714 analytic: 1.191714, relative error: 1.496183e-08\n",
      "numerical: 0.771905 analytic: 0.771905, relative error: 1.142845e-07\n",
      "numerical: -6.418611 analytic: -6.418611, relative error: 2.891616e-09\n",
      "numerical: 1.981861 analytic: 1.981861, relative error: 2.547035e-08\n",
      "numerical: -7.198350 analytic: -7.198350, relative error: 3.609863e-09\n",
      "numerical: -1.162548 analytic: -1.162548, relative error: 1.456676e-08\n",
      "numerical: 1.213932 analytic: 1.213932, relative error: 4.045950e-09\n",
      "numerical: 2.449987 analytic: 2.449987, relative error: 5.574473e-09\n",
      "numerical: -0.005899 analytic: -0.005899, relative error: 4.120284e-07\n",
      "numerical: 1.077632 analytic: 1.077632, relative error: 3.213690e-09\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: \t\t2.368449e+00 computed in 0.327115s\n",
      "vectorized loss: \t2.368449e+00 computed in 0.017604s\n",
      "naive gradient: \t-3.1220300007136648\n",
      "vectorized gradient: \t-3.1220300007136683\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: \\t\\t%e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: \\t%e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "print(f'naive gradient: \\t{grad_naive[0,0]}')\n",
    "print(f'vectorized gradient: \\t{grad_vectorized[0,0]}')\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "tuning",
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.323265 val accuracy: 0.346000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.310571 val accuracy: 0.328000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.320796 val accuracy: 0.335000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.307306 val accuracy: 0.316000\n",
      "best validation accuracy achieved during cross-validation: 0.346000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "\n",
    "# Provided as a reference. You may or may not want to change these hyperparameters\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "regularization_strengths = [2.5e4, 5e4]\n",
    "\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "def tryParams(lr, reg, best_val, best_softmax):\n",
    "    smax = Softmax()\n",
    "    loss_hist = smax.train(X_train, y_train, learning_rate=lr, reg=reg,\n",
    "                          num_iters=5000, verbose=False)\n",
    "    y_train_pred = np.mean(y_train == smax.predict(X_train))\n",
    "    y_val_pred = np.mean(y_val == smax.predict(X_val))\n",
    "    results[(lr, reg)] = (y_train_pred,y_val_pred)\n",
    "    if y_val_pred > best_val: \n",
    "        best_val = y_val_pred\n",
    "        best_softmax = smax\n",
    "    return best_val, best_softmax\n",
    "    \n",
    "for lr in learning_rates:\n",
    "    for reg in regularization_strengths:\n",
    "        best_val, best_softmax = tryParams(lr, reg, best_val, best_softmax)\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "test"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.336000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 2** - *True or False*\n",
    "\n",
    "Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$\n",
    "\n",
    "Yes! \n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$\n",
    "\n",
    "The datapoint $x_i$ should have the following property:\n",
    "\n",
    "for all $w_j$, $ w_{j}^{T} x_i - w_{yi}^{T} x_i + \\Delta  > 0 $, so the SVM loss will be unchanged, but Softmax loss will still change.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
